/**
 * 数据导出服务
 * 提供账号和标签数据的导出功能
 */

import { getAllAccounts } from '../accountService.js';
import { getAllTags } from '../tagService.js';

/**
 * 导出加密备份文件
 * @param {string} password 加密密码
 * @returns {Promise<Object>} 加密后的备份数据
 */
export async function exportEncryptedBackup(password) {
	try {
		const accounts = getAllAccounts();
		const tags = getAllTags();
		const now = Date.now();
		
		// 转换标签格式
		const tagList = tags.map(tag => ({
			tagName: tag.name
		}));
		
		// 转换账号格式
		const accountList = accounts.map(account => {
			const accountItemList = [];
			
			// 添加账号字段
			if (account.account) {
				accountItemList.push({
					itemName: '账号',
					itemValue: account.account
				});
			}
			
			// 添加密码字段
			if (account.password) {
				accountItemList.push({
					itemName: '密码',
					itemValue: account.password
				});
			}
			
			// 添加备注字段
			if (account.note) {
				accountItemList.push({
					itemName: '备注',
					itemValue: account.note
				});
			}
			
			// 添加自定义字段
			if (account.customFields) {
				Object.keys(account.customFields).forEach(key => {
					if (account.customFields[key]) {
						accountItemList.push({
							itemName: key,
							itemValue: account.customFields[key]
						});
					}
				});
			}
			
			// 转换标签格式
			const tagListForAccount = [];
			if (account.tag) {
				const tagNames = account.tag.split(',').map(t => t.trim()).filter(t => t);
				tagNames.forEach(tagName => {
					tagListForAccount.push({ tagName: tagName });
				});
			}
			
			// 转换最后编辑时间
			let lastEditTime = now;
			if (account.updatedAt) {
				lastEditTime = new Date(account.updatedAt).getTime();
			} else if (account.lastModified) {
				lastEditTime = new Date(account.lastModified).getTime();
			}
			
			return {
				name: account.name,
				accountItemList: accountItemList,
				tagList: tagListForAccount,
				favorite: account.isFavorite || false,
				lastEditTime: lastEditTime
			};
		});
		
		const backupData = {
			version: 13,
			tagList: tagList,
			accountList: accountList,
			lastEditTime: now,
			dynamicPasswordList: []
		};
		
		// 加密数据
		const encryptedData = await encryptData(JSON.stringify(backupData), password);
		
		// 生成文件名
		const filename = `ENCRYPTED_${formatDateTimeForFilename(new Date())}_${accounts.length}.enc`;
		
		return {
			data: encryptedData,
			filename: filename,
			type: 'encrypted',
			mimeType: 'application/octet-stream'
		};
	} catch (error) {
		throw new Error('导出加密备份失败: ' + error.message);
	}
}

/**
 * 导出 JSON 格式数据
 * @returns {Object} JSON 格式的备份数据
 */
export function exportJSONData() {
	try {
		const accounts = getAllAccounts();
		const tags = getAllTags();
		const now = Date.now();
		
		// 转换标签格式
		const tagList = tags.map(tag => ({
			tagName: tag.name
		}));
		
		// 转换账号格式
		const accountList = accounts.map(account => {
			const accountItemList = [];
			
			// 添加账号字段
			if (account.account) {
				accountItemList.push({
					itemName: '账号',
					itemValue: account.account
				});
			}
			
			// 添加密码字段
			if (account.password) {
				accountItemList.push({
					itemName: '密码',
					itemValue: account.password
				});
			}
			
			// 添加备注字段
			if (account.note) {
				accountItemList.push({
					itemName: '备注',
					itemValue: account.note
				});
			}
			
			// 添加自定义字段
			if (account.customFields) {
				Object.keys(account.customFields).forEach(key => {
					if (account.customFields[key]) {
						accountItemList.push({
							itemName: key,
							itemValue: account.customFields[key]
						});
					}
				});
			}
			
			// 转换标签格式
			const tagListForAccount = [];
			if (account.tag) {
				const tagNames = account.tag.split(',').map(t => t.trim()).filter(t => t);
				tagNames.forEach(tagName => {
					tagListForAccount.push({ tagName: tagName });
				});
			}
			
			// 转换最后编辑时间
			let lastEditTime = now;
			if (account.updatedAt) {
				lastEditTime = new Date(account.updatedAt).getTime();
			} else if (account.lastModified) {
				lastEditTime = new Date(account.lastModified).getTime();
			}
			
			return {
				name: account.name,
				accountItemList: accountItemList,
				tagList: tagListForAccount,
				favorite: account.isFavorite || false,
				lastEditTime: lastEditTime
			};
		});
		
		const exportData = {
			version: 13,
			tagList: tagList,
			accountList: accountList,
			lastEditTime: now,
			dynamicPasswordList: []
		};
		
		// 生成文件名
		const filename = `JSON_${formatDateTimeForFilename(new Date())}_${accounts.length}.txt`;
		
		// 第一行：版本标识
		const data = `ACCOUNTBOX_JSON_13\n${JSON.stringify(exportData)}`;
		
		return {
			data: data,
			filename: filename,
			type: 'json',
			mimeType: 'text/plain'
		};
	} catch (error) {
		throw new Error('导出 JSON 数据失败: ' + error.message);
	}
}

/**
 * 导出 TEXT 格式数据
 * @returns {Object} TEXT 格式的备份数据
 */
export function exportTEXTData() {
	try {
		const accounts = getAllAccounts();
		
		// 前11行模板说明（固定格式）
		let textData = 'ACCOUNTBOX_TEXT_11\n';
		textData += '\n';
		textData += '----------- 模板说明 -----------\n';
		textData += '1. 多个账号内容之间，用一行空行隔开\n';
		textData += '2. 名称字段，是必须填写的，不能缺失\n';
		textData += '3. 标签字段，多个标签名用中文，拼接\n';
		textData += '4. 所有字段名称内容，用中文的：拼接\n';
		textData += '5. 请勿改动前 11 行否则可能无法导入\n';
		textData += '6. 请从第 12 行开始编写你的个人数据\n';
		textData += '----------- 模板说明 -----------\n';
		textData += '\n';
		
		// 从第12行开始添加账号数据
		accounts.forEach((account, index) => {
			if (index > 0) {
				textData += '\n'; // 账号之间用空行隔开
			}
			
			// 名称（必填）
			textData += `名称：${account.name || ''}\n`;
			
			// 账号
			if (account.account) {
				textData += `账号：${account.account}\n`;
			}
			
			// 密码
			if (account.password) {
				textData += `密码：${account.password}\n`;
			}
			
			// 备注
			if (account.note) {
				textData += `备注：${account.note}\n`;
			}
			
			// 自定义字段
			if (account.customFields) {
				Object.keys(account.customFields).forEach(key => {
					if (account.customFields[key]) {
						textData += `${key}：${account.customFields[key]}\n`;
					}
				});
			}
			
			// 标签（多个标签用中文逗号拼接）
			if (account.tag) {
				// 如果标签是用逗号分隔的，转换为中文逗号
				const tags = account.tag.split(',').map(t => t.trim()).filter(t => t);
				if (tags.length > 0) {
					textData += `标签：${tags.join('，')}\n`;
				} else {
					textData += `标签：\n`;
				}
			} else {
				textData += `标签：\n`;
			}
		});
		
		// 生成文件名
		const filename = `TEXT_${formatDateTimeForFilename(new Date())}_${accounts.length}.txt`;
		
		return {
			data: textData,
			filename: filename,
			type: 'text',
			mimeType: 'text/plain'
		};
	} catch (error) {
		throw new Error('导出 TEXT 数据失败: ' + error.message);
	}
}

/**
 * 格式化日期时间（用于文件名）
 * @param {Date} date 日期对象
 * @returns {string} 格式化后的日期时间字符串 (YYYYMMDDHHmmss)
 */
function formatDateTimeForFilename(date) {
	const d = new Date(date);
	const year = d.getFullYear();
	const month = String(d.getMonth() + 1).padStart(2, '0');
	const day = String(d.getDate()).padStart(2, '0');
	const hour = String(d.getHours()).padStart(2, '0');
	const minute = String(d.getMinutes()).padStart(2, '0');
	const second = String(d.getSeconds()).padStart(2, '0');
	return `${year}${month}${day}${hour}${minute}${second}`;
}

/**
 * 格式化日期（用于文件名）
 * @param {Date} date 日期对象
 * @returns {string} 格式化后的日期字符串 (YYYYMMDD)
 */
function formatDate(date) {
	const d = new Date(date);
	const year = d.getFullYear();
	const month = String(d.getMonth() + 1).padStart(2, '0');
	const day = String(d.getDate()).padStart(2, '0');
	return `${year}${month}${day}`;
}

/**
 * 格式化日期时间
 * @param {Date} date 日期对象
 * @returns {string} 格式化后的日期时间字符串
 */
function formatDateTime(date) {
	const d = new Date(date);
	const year = d.getFullYear();
	const month = String(d.getMonth() + 1).padStart(2, '0');
	const day = String(d.getDate()).padStart(2, '0');
	const hour = String(d.getHours()).padStart(2, '0');
	const minute = String(d.getMinutes()).padStart(2, '0');
	const second = String(d.getSeconds()).padStart(2, '0');
	return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
}

/**
 * 加密数据
 * @param {string} data 原始数据
 * @param {string} password 密码
 * @returns {Promise<string>} 加密后的数据（base64编码）
 */
async function encryptData(data, password) {
	try {
		// 简单的加密方案：使用 XOR 加密 + Base64 编码
		// 生成密码哈希（简单的字符串哈希）
		let passwordHash = 0;
		for (let i = 0; i < password.length; i++) {
			const char = password.charCodeAt(i);
			passwordHash = ((passwordHash << 5) - passwordHash) + char;
			passwordHash = passwordHash & passwordHash; // 转换为32位整数
		}
		
		// XOR 加密
		const encryptedBytes = [];
		const dataBytes = new TextEncoder().encode(data);
		
		for (let i = 0; i < dataBytes.length; i++) {
			const keyByte = (passwordHash + i) % 256;
			encryptedBytes.push(dataBytes[i] ^ keyByte);
		}
		
		// 转换为 Base64（手动实现，跨平台兼容）
		const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
		let base64 = '';
		let i = 0;
		while (i < encryptedBytes.length) {
			const a = encryptedBytes[i++];
			const b = i < encryptedBytes.length ? encryptedBytes[i++] : 0;
			const c = i < encryptedBytes.length ? encryptedBytes[i++] : 0;
			
			const bitmap = (a << 16) | (b << 8) | c;
			base64 += chars.charAt((bitmap >> 18) & 63);
			base64 += chars.charAt((bitmap >> 12) & 63);
			base64 += i - 2 < encryptedBytes.length ? chars.charAt((bitmap >> 6) & 63) : '=';
			base64 += i - 1 < encryptedBytes.length ? chars.charAt(bitmap & 63) : '=';
		}
		
		return Promise.resolve(base64);
	} catch (error) {
		throw new Error('加密失败: ' + error.message);
	}
}

